package com.augurit.common.system.service.org.impl;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springside.modules.orm.Page;
import com.augurit.common.base.form.ResultForm;
import com.augurit.common.constant.OrgConstant;
import com.augurit.common.dao.AcRoleDao;
import com.augurit.common.dao.OmOrgAdminDao;
import com.augurit.common.dao.OmOrgDao;
import com.augurit.common.dao.OmUserOrgDao;
import com.augurit.common.entity.OmOrg;
import com.augurit.common.syscode.service.ISysCodeService;
import com.augurit.common.syscode.web.form.SysCodeForm;
import com.augurit.common.system.convert.OmGroupConverter;
import com.augurit.common.system.convert.OmOrgConverter;
import com.augurit.common.system.service.org.IOmGroupService;
import com.augurit.common.system.service.org.IOmOrgService;
import com.augurit.common.system.service.org.IOmPositionService;
import com.augurit.common.system.service.org.IOmUserService;
import com.augurit.common.system.util.MsgUtils;
import com.augurit.common.system.util.OrgUtils;
import com.augurit.common.system.util.TreeUtils;
import com.augurit.common.system.web.org.form.OmGroupForm;
import com.augurit.common.system.web.org.form.OmOrgForm;
import com.augurit.common.system.web.org.form.OmPositionForm;
import com.augurit.common.system.web.org.form.OmUserForm;
import com.augurit.common.util.HqlUtils;
import com.augurit.common.util.PageUtils;
import com.augurit.common.util.lang.CollectionUtils;
import com.augurit.gzcgwsp.sendNotice.service.IUserForFxService;

/**
 * 机构部门逻辑实现类
 */
@Service
@Transactional
public class OmOrgServiceImpl implements IOmOrgService {

	// DAO 引用
	@Autowired
	private OmOrgDao omOrgDao;

	@Autowired
	private OmUserOrgDao omUserOrgDao;

	@Autowired
	private OmOrgAdminDao omOrgAdminDao;
	
	@Autowired
	private AcRoleDao acRoleDao;

	@Autowired
	private IOmUserService omUserService;

	@Autowired
	private IOmPositionService omPositionService;
	
	@Autowired
	private IOmGroupService omGroupService;

	@Autowired
	private ISysCodeService sysCodeService;
	
	@Autowired
	private IUserForFxService userForFxService;

	
	/**
	 * 根据机构ID获取机构Form对象
	 * @param id 机构主键
	 * @return 机构Form对象
	 */
	@Transactional(readOnly = true)
	public OmOrgForm get(Long id) {
		OmOrgForm form = omOrgDao.getForm(id);
		
		if (form.getParentOrgId() != null) {
			OmOrg omOrg = omOrgDao.get(form.getParentOrgId());
			form.setParentOrgName(omOrg.getOrgName());
		}
		return form;
	}

	/**
	 * 根据机构ID获取机构名称
	 * @param id 机构主键
	 * @return 机构名称
	 */
	@Transactional(readOnly = true)
	public String getOrgName(Long id) {
		return omOrgDao.getOrgName(id);
	}
	
	/**
	 * 将机构ID列表转换为OmOrgForm列表
	 * @list 机构id列表
	 * @return OmOrgForm列表
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> get(Long[] ids) {
		if (ids != null && ids.length > 0) {
			String hql = "from OmOrg ps where" + HqlUtils.buildOrCondition("ps", "orgId", ids) + "order by ps.sortNo asc";
			List<OmOrg> list = omOrgDao.find(hql);
			return OmOrgConverter.convertToForm(list);
		}
		return null;
	}
	
	/**
	 * 保存机构Form对象数组
	 * @param forms 机构Form对象或对象数组
	 */
	public void save(OmOrgForm... forms) {
		if (forms != null)
			for (OmOrgForm form : forms)
				omOrgDao.save(form);
	}

	/**
	 * 根据主键ID集合删除多个机构对象
	 * @param ids 机构主键或主键数组
	 */
	public void delete(Long... ids) {
		if (ids != null)
			omOrgDao.delete(ids);
	}

	/**
	 * 移动机构节点到另一机构节点下
	 * @param orgId 本机构ID
	 * @param targetParentOrgId 要移动到的目标机构ID
	 */
	public void moveOrg(Long orgId, Long targetParentOrgId) {
		if (orgId != null) {

			OmOrg entity = omOrgDao.get(orgId);

			// 更新原父机构节点
			omOrgDao.updateOrgAfterRemoveChildren(entity.getParentOrgId());

			// 将本机构节点的父节点改为目标机构节点
			entity.setParentOrgId(targetParentOrgId);
			omOrgDao.save(entity);

			// 更新目标父机构节点
			omOrgDao.updateOrgAfterAddChildren(targetParentOrgId);

			// 更新该节点以及所有子节点序列
			omOrgDao.updateOrgSeqAfterMoveOrg(entity);
		}
	}

	/**
	 * 级联删除指定机构及其所有关联的对象
	 * @param orgIds 机构主键或主键数组
	 */
	public void deleteOrgCascade(Long... orgIds) {
		if (orgIds != null) {
			for (Long orgId : orgIds) {
				// 删除所有子机构
				deleteAllChildOrgs(orgId);

				// 删除本机构关联的岗位、用户和角色
				deleteOrgRelatedElements(orgId);

				// 更新被删除机构的父机构数据
				omOrgDao.updateOrgAfterRemoveChildren(this.get(orgId).getParentOrgId());

				// 删除本机构本身
				omOrgDao.delete(orgId);
				//同步行政组织
				userForFxService.deleteOrganization(orgId);
			}
		}
	}
	
	/**
	 * 级联删除指定机构及其所有关联的对象  方欣删除行政组织
	 * @param orgIds 机构主键或主键数组
	 */
	public void deleteOrgCascadeForFx(Long... orgIds) {
		if (orgIds != null) {
			for (Long orgId : orgIds) {
				// 删除所有子机构
				deleteAllChildOrgs(orgId);

				// 删除本机构关联的岗位、用户和角色
				deleteOrgRelatedElements(orgId);

				// 更新被删除机构的父机构数据
				omOrgDao.updateOrgAfterRemoveChildren(this.get(orgId).getParentOrgId());

				// 删除本机构本身
				omOrgDao.delete(orgId);
			}
		}
	}

	/**
	 * 删除所有子机构及子机构关联的用户和岗位对象
	 * @param parentOrgId 父机构主键
	 */
	public void deleteAllChildOrgs(Long parentOrgId) {
		if (parentOrgId != null) {

			// 获取所有子机构主键ID集合
			List<Long> childOrgIds = omOrgDao.getAllChildOrgIds(parentOrgId);

			for (Long childOrgId : childOrgIds) {

				// 删除指定机构关联的岗位和用户
				deleteOrgRelatedElements(childOrgId);

				// 删除机构本身
				omOrgDao.delete(childOrgId);
			}
		}
	}

	/**
	 * 删除指定机构关联的岗位、用户和角色
	 * @param orgId 机构主键
	 */
	public void deleteOrgRelatedElements(Long orgId) {
		if (orgId != null) {

			// 删除机构关联的岗位
			omPositionService.deletePosCascade(orgId);

			// 删除机构关联的用户
			omUserOrgDao.deleteByOrgId(orgId);
			omOrgAdminDao.deleteByOrgId(orgId);

			// TODO: 删除机构关联的角色
			acRoleDao.disAssociationRoleByOrgId(orgId);

		}
	}

	/**
	 * 获取指定机构的所有子机构对象列表，以非树结构组织数据
	 * @param parentOrgId 父机构主键
	 * @return 机构的所有子机构对象列表
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getAllChildOrgs(Long parentOrgId) {
		List<OmOrg> list = omOrgDao.getAllChildOrgs(parentOrgId);
		return OmOrgConverter.convertToFormList(list);
	}
	
	/**
	 * 获取指定机构的所有子机构ID列表
	 * @param parentOrgId 父机构主键
	 * @return 机构的所有子机构ID列表
	 */
	@Transactional(readOnly = true)
	public List<Long> getAllChildOrgIds(Long parentOrgId) {
		return omOrgDao.getAllChildOrgIds(parentOrgId);
	}

	/**
	 * 分页获取指定机构的所有子机构列表
	 * @param parentOrgId 父机构主键
	 * @return
	 */
	@Transactional(readOnly = true)
	public Page<OmOrgForm> getAllChildOrgs(Long parentOrgId, Page<OmOrgForm> page) {

		// 建立新的分页对象
		Page<OmOrg> pg = PageUtils.newPageInstance(page);

		// 按过滤条件分页查找对象
		String hql = "from OmOrg ps where ps.orgSeq like ? and ps.orgId != ?";
		omOrgDao.findPage(pg, hql, "%." + parentOrgId + ".%", parentOrgId);

		// 转换为Form对象列表并赋值到原分页对象中
		List<OmOrgForm> list = OmOrgConverter.convertToFormList(pg.getResult());
		PageUtils.copy(pg, list, page);

		return page;
	}
	
	/**
	 * 获取某一个机构的直属父机构，顶级父机构的父机构为null
	 * @param orgId 机构id
	 * @return 直属父机构id
	 */
	@Transactional(readOnly = true)
	public Long getDirectParentOrgOfOrg(Long orgId){
		if(orgId != null){
			OmOrgForm form = this.get(orgId);
			return OrgUtils.getDirectParentObjId(form.getOrgSeq());
		}
		return null;
	}
	
	/**
	 * 获取某一个机构的间接父机构，顶级父机构的间接父机构为null
	 * @param orgId 机构id
	 * @return 间接父机构id列表
	 */
	@Transactional(readOnly = true)
	public List<Long> getIndirectParentOrgOfOrg(Long orgId){
		List<Long> orgIds = null;
		if(orgId != null){
			OmOrgForm form = this.get(orgId);
			return OrgUtils.getIndirectParentObjIds(form.getOrgSeq());
		}
		return orgIds;
	}
	
	/**
	 * 获取某一个机构的所有父机构（包括直属父机构和间接父机构），顶级父机构的间接父机构为null
	 * @param orgId 机构id
	 * @return 所有父机构id列表
	 */
	@Transactional(readOnly = true)
	public List<Long> getAllParentOrgOfOrg(Long orgId){
		List<Long> orgIds = null;
		if(orgId != null){
			OmOrgForm form = this.get(orgId);
			return OrgUtils.getAllParentObjIds(form.getOrgSeq());
		}
		
		return orgIds;
	}
	
	/**
	 * 获取某一个用户的所有父机构（包括直属父机构和间接父机构）
	 * @param userId 用户id
	 * @return 所有父机构id列表
	 */
	@Transactional(readOnly = true)
	public List<Long> getAllParentOrgOfUser(Long userId){
		if(userId != null){
			Set<Long> orgIdSet = new HashSet();
			// 获取用户从他所属机构(包括直属机构和间接机构)获得的角色
			List<Long> directParentOrgIds = omUserOrgDao.getOrgIds(userId);
			
			if(directParentOrgIds != null && directParentOrgIds.size() > 0){
				orgIdSet.addAll(directParentOrgIds);
				
				for(Long orgId: directParentOrgIds){
					List<Long> indirectParentOrgIds = this.getAllParentOrgOfOrg(orgId);
					if(indirectParentOrgIds != null && indirectParentOrgIds.size() > 0)
						orgIdSet.addAll(indirectParentOrgIds);
				}
				return CollectionUtils.toLongList(orgIdSet);
			}
		}
		return null;
	}
	
	
	/**
	 * 获取指定机构的直属子机构列表
	 * @param parentOrgId 父机构主键
	 * @return 机构的直属子机构对象列表
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getChildOrgs(Long parentOrgId) {
		return omOrgDao.getChildOrgs(parentOrgId);
	}
	
	/**
	 * 获取指定父机构下的具有管理授权范围内的机构列表
	 * @param parentOrgId
	 * @param allRelatedOrgIds
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getChildOrgsInAllRelatedOrgIds(Long parentOrgId, Long[] allRelatedOrgIds) {
		if(parentOrgId != null){
			
			String hql = "from OmOrg ps where" 
				+ HqlUtils.buildOrCondition("ps", "orgId", allRelatedOrgIds) 
				+ " and ps.parentOrgId=" + parentOrgId + " order by ps.sortNo asc";
			List<OmOrg> list = omOrgDao.find(hql);
			
			return OmOrgConverter.convertToFormList(list);
		}else
			return null;
	}

	/**
	 * 分页获取指定机构的直属子机构列表
	 * @param parentOrgId 父机构主键
	 * @return 机构的直属子机构列表
	 */
	@Transactional(readOnly = true)
	public Page<OmOrgForm> getChildOrgs(Long parentOrgId, Page<OmOrgForm> page, Map<String, List<SysCodeForm>> sysCodeBuffer) {

		// 建立新的分页对象
		Page<OmOrg> pg = PageUtils.newPageInstance(page);

		// 按过滤条件分页查找对象
		String hql = "from OmOrg ps where ps.parentOrgId = ?";
		List<Long> values = new ArrayList<Long>();
		values.add(parentOrgId);
		pg = omOrgDao.findPage(pg, hql, values);

		// 转换为Form对象列表并赋值到原分页对象中
		List<OmOrgForm> list = OmOrgConverter.convertToFormList(pg.getResult(),
				sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_TYPE, sysCodeBuffer), 
				sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_GRADE, sysCodeBuffer), 
				sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_STATUS, sysCodeBuffer));

		PageUtils.copy(pg, list, page);

		return page;
	}

	/**
	 * 获取指定机构的树结构子机构及子子机构
	 * @param parentOrgId 父机构主键
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getChildOrgsByTree(Long parentOrgId) {

		// 获取所有子机构
		List<OmOrgForm> children = this.getAllChildOrgs(parentOrgId);

		// 将所有子机构按树结构组织
		return TreeUtils.constructOrgTree(children);
	}

	/**
	 * 获取指定机构的直属岗位列表
	 * @param orgId 机构主键
	 * @return 机构的直属岗位列表
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getPositionsByOrgId(Long orgId) {
		return omPositionService.getPositionsByOrgId(orgId);
	}

	/**
	 * 根据管理用户权限，获取指定机构的直属岗位列表
	 * @param orgId 机构主键
	 * @return 机构的直属岗位列表
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getPositions(Long adminUserId, Long orgId) {

		// 系统管理员
		if (omUserService.isSystemAdmin(adminUserId))
			return omPositionService.getPositionsByOrgId(orgId);

		// 普通用户
		else {
			List<Long> orgIds = this.getCanManageOrgIds(adminUserId);
			if (orgIds.contains(orgId))
				return this.getPositionsByOrgId(orgId);
		}
		return null;
	}

	/**
	 * 分页获取指定机构的直属岗位列表
	 * @param orgId 机构主键
	 * @return 机构的直属岗位列表
	 */
	@Transactional(readOnly = true)
	public Page<OmPositionForm> getPositionsByOrg(Long orgId, Page<OmPositionForm> page) {
		return omPositionService.getPositionsByOrgId(orgId, page);
	}
	
	/**
	 * 分页获取指定工作组的直属岗位列表
	 * @param groupId 工作组主键
	 * @return
	 */
	@Transactional(readOnly = true)
	public Page<OmPositionForm> getPositionsByGroup(Long groupId, Page<OmPositionForm> page){
		return omPositionService.getPositionsByGroup(groupId, page);
	}

	/**
	 * 获取指定机构的直属岗位及其子岗位列表，并且以树结构组织数据
	 * @param orgId 机构主键
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getPositionsByTree(Long orgId) {
		if (orgId != null) {
			// 获取指定机构的直属岗位和所有子岗位
			List<OmPositionForm> children = omPositionService
					.getAllPositionsByOrgId(orgId);

			// 为所有的岗位装载用户
			if (children != null && children.size() > 0)
				omPositionService.loadUsers(children);

			// 以树结构组织数据
			return TreeUtils.constructPositionTree(children);
		} else
			return null;
	}

	/**
	 * 获取指定机构的直属用户列表
	 * @param orgId 机构主键
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmUserForm> getUsers(Long orgId) {
		return omUserService.getUsers(orgId);
	}

	/**
	 * 分页获取指定机构的直属用户列表
	 * @param orgId
	 * @return
	 */
	@Transactional(readOnly = true)
	public Page<OmUserForm> getUsers(Long orgId, Page<OmUserForm> page) {
		return omUserService.getUsers(orgId, page);
	}

	/**
	 * 移动岗位到新父岗位节点下
	 * @param posId 岗位ID
	 * @param targetParentPosId 用户所要移到的新父岗位ID
	 */
	public void movePosition(Long posId, Long targetParentPosId) {
		omPositionService.movePosition(posId, targetParentPosId);
	}

	/**
	 * 移动岗位到另一机构节点下
	 * @param posId 岗位ID
	 * @param targetOrgId 用户所要移到的机构ID
	 */
	public void movePositionToOrg(Long posId, Long targetOrgId) {
		omPositionService.movePositionToOrg(posId, targetOrgId);
	}

	/**
	 * 移动用户到另一岗位
	 * @param userId 用户主键
	 * @param oldPosId 用户原来所在的岗位
	 * @param targetPosId 要移动到的岗位主键
	 */
	public void moveUserToPosition(Long userId, Long oldPosId, Long targetPosId) {
		omUserService.moveUserToPosition(userId, oldPosId, targetPosId);
	}

	/**
	 * 移动用户到另一机构
	 * @param userId 用户主键
	 * @param targetOrgId 要移动到的机构主键
	 */
	public void moveUserToOrg(Long userId, Long oldOrgId, Long targetOrgId) {
		omUserService.moveUserToOrg(userId, oldOrgId, targetOrgId);
		userForFxService.moveUserToOrg(userId, oldOrgId, targetOrgId);
	}

	/**
	 * 获取最上层机构列表
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getTopOrgs() {
		return omOrgDao.getTopOrgs();
	}

	/**
	 * 根据机构ID获取关联的直属元素并存放到Form的几个LIST属性中
	 * @param orgId 机构主键
	 * @return
	 */
	@Transactional(readOnly = true)
	public OmOrgForm getOrgRelatedElements(Long orgId) {
		OmOrgForm form = new OmOrgForm();
		form.setChildren(this.getChildOrgs(orgId));
		form.setUsers(this.getUsers(orgId));
		form.setPostions(this.getPositionsByOrgId(orgId));
		return form;
	}

	/**
	 * 获取指定机构的下级用户，但这些用户与机构的下级岗位以及它们的子子岗位没有关联
	 * @param orgId 指定机构主键盘
	 * @return 用户列表
	 */
	@Transactional(readOnly = true)
	public List<OmUserForm> getNoPositionUsers(Long orgId) {
		List<OmUserForm> list = null;
		if (orgId != null) {
			// 获取指定机构的下级用户
			List<OmUserForm> users = this.getUsers(orgId);

			// 获取指定机构的下级岗位以及它们的子子岗位所关联的用户的主键
			List<Long> userIds = omPositionService.getHavePositionUsers(orgId, OrgConstant.PARTY_TYPE_ORG);

			// 判断用户是否属于指定的用户主键列表
			list = getUnbelongUsers(users, userIds);
		}
		return list;
	}

	/**
	 * 带权限控制的getNoPositionUsers()方法
	 * @param orgId 指定机构主键盘
	 * @return 用户列表
	 */
	@Transactional(readOnly = true)
	public List<OmUserForm> getUsersWithNoPostion(Long adminUserId, Long orgId) {
		List<OmUserForm> list = null;
		if (orgId != null) {
			// 系统管理员
			if (this.omUserService.isSystemAdmin(adminUserId))
				list = this.getNoPositionUsers(orgId);

			// 普通用户
			else {
				List<Long> orgIds = this.getCanManageOrgIds(adminUserId);
				if (orgIds.contains(orgId))
					list = this.getNoPositionUsers(orgId);
			}
		}
		return list;
	}

	/**
	 * 判断用户users列表中的用户对象是否属于指定用户主键userIds列表， 返回不属于userIds的用户对象集合
	 * @param users 需要判断的用户对象对象列表
	 * @param userIds 指定的用户主键列表
	 * @return list 不属于userIds的用户对象集合
	 */
	@Transactional(readOnly = true)
	public static List<OmUserForm> getUnbelongUsers(List<OmUserForm> users,
			List<Long> userIds) {

		List<OmUserForm> list = null;
		if (users != null && users.size() != 0) {
			list = new ArrayList<OmUserForm>();
			if (userIds != null && userIds.size() != 0) {
				for (int i = 0; i < users.size(); i++) {
					OmUserForm form = users.get(i);
					boolean flag = false;
					for (int j = 0; j < userIds.size(); j++) {
						if (form.getUserId().longValue() == userIds.get(j)
								.longValue()) {
							flag = true;
						}
					}
					if (flag == false) {
						list.add(form);
					}
				}
			} else {
				list = users;
			}
		}
		return list;
	}

	/** ****************带权限参数方法************************** */
	/**
	 * 判断管理用户是否具有指定机构列表的全部管理权限，分管理用户是超级管理员和普通用户2种
	 * 情况判断，若拥有全部权限，则返回true，否则，返回false；
	 * @param userId 管理用户主键
	 * @param orgIds 指定机构主键或主键数组
	 * @return 管理用户是否具有指定机构列表的全部管理权限
	 */
	@Transactional(readOnly = true)
	public boolean canManageOrg(Long userId, Long... orgIds) {
		if (omUserService.isSystemAdmin(userId) || isOrgAdmin(userId, orgIds))
			return true;
		else
			return false;
	}

	/**
	 * 根据用户权限删除机构信息，若管理用户拥有权限，返回成功删除信息 否则，返回删除失败信息
	 * @param orgIds 指定机构主键或主键数组
	 * @param userId 用户主键
	 * @return ResultDto<Object> 是否删除成功的信息
	 */
	public ResultForm<Object> delete(Long userId, Long... orgIds) {
		ResultForm<Object> result = new ResultForm<Object>(false);

		// 有管理权限
		if (canManageOrg(userId, orgIds)) {
			this.delete(orgIds);
			result.setSuccess(true);
		}
		// 没有管理权限
		else
			MsgUtils.addNoOrgPrivilegeError(result);

		return result;
	}

	/**
	 * 根据用户权限，级联删除指定机构及其所有关联的对象；若为超级管理员， 直接调用普通的deleteOrgCascade方法，普通用户，需要判断用户是否
	 * 有所有机构的权限，返回是否成功级联删除的信息。
	 * @param userId 用户主键
	 * @param orgIds 机构主键或主键数组
	 * @return 是否成功级联删除的信息
	 */
	public ResultForm<Object> deleteOrgCascade(Long userId, Long... orgIds) {
		ResultForm<Object> result = new ResultForm<Object>(false);

		// 有管理权限
		if (canManageOrg(userId, orgIds)) {
			this.deleteOrgCascade(orgIds);
			result.setSuccess(true);
		}
		// 没有管理权限
		else
			MsgUtils.addNoOrgPrivilegeError(result);

		return result;
	}

	/**
	 * 根据用户权限获取机构信息，对象不存在或无权限查看则返回NULL
	 * @param orgId 机构主键
	 * @param userId 用户主键
	 * @return 是否成功获取，若成功获取，返回成功获取的结果，若失败，返回失败的提示信息
	 */
	@Transactional(readOnly = true)
	public ResultForm<OmOrgForm> get(Long userId, Long orgId) {

		ResultForm<OmOrgForm> result = new ResultForm<OmOrgForm>(false);

		// 有管理权限
		if (canManageOrg(userId, orgId)) {
			result.setResult(this.get(orgId));
			result.setSuccess(true);
		}
		// 没有管理权限
		else
			MsgUtils.addNoOrgPrivilegeError(result);

		return result;
	}

	/**
	 * 根据用户权限获取所有可管理机构ID集合
	 * @param userId
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<Long> getAuthedOrgIds(Long userId){
		return omOrgAdminDao.getCanManageOrgIds(userId);
	}
	
	@Transactional(readOnly = true)
	public List<OmOrgForm> getAuthedOrgs(Long userId){
		return omOrgAdminDao.getCanManageOrgs(userId);
	}
	
	/**
	 * 根据用户权限获取可管理的最上层机构列表
	 * @param authUserId 用户主键
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getCanManageTopOrgs(Long authUserId) {
		return getCanManageOrAuthTopOrgs(authUserId, false);
	}
	
	/**
	 * 根据用户权限获取可管理且可继续授权的最上层机构列表
	 * @param authUserId 用户主键
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getCanManageAndAuthTopOrgs(Long authUserId) {
		return getCanManageOrAuthTopOrgs(authUserId, true);
	}

	/**
	 * 根据用户权限获取可管理或可继续授权的最上层机构列表
	 * @param authUserId
	 * @param needLoadAuthOrgs 是否启用获取可继续授权机构约束
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getCanManageOrAuthTopOrgs(Long authUserId, boolean needLoadAuthOrgs) {
		if(authUserId != null) {
			
			//系统管理员
			if (omUserService.isSystemAdmin(authUserId)) {
				List<OmOrgForm> topOrgs = this.getTopOrgs();
				OrgUtils.setOrgCheckedProp(topOrgs, true);
				return topOrgs;
			} 
			
			//机构管理员
			else {
				
				List<OmOrgForm> authedOrgs = null;
				
				if(needLoadAuthOrgs)
					authedOrgs = omOrgAdminDao.getCanManageAndAuthOrgs(authUserId);
				else
					authedOrgs = omOrgAdminDao.getCanManageOrgs(authUserId);
				
				List<OmOrgForm> topOrgs = this.get(OrgUtils.getTopOrgIds(authedOrgs));
				OrgUtils.setTopOrgCheckedProp(topOrgs, authedOrgs);
				return topOrgs;
			}
		}
		
		return null;
	}
	
	/**
	 * 根据权限查询指定父机构下的所有具有管理权限的子机构
	 * @param authUserId 机构管理用户ID
	 * @param parentOrgId 父机构ID
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getCanManageChildOrgs(Long authUserId, Long parentOrgId) {
		return getCanManageOrAuthChildOrgs(authUserId, parentOrgId, false);
	}
	
	/**
	 * 根据权限查询指定父机构下的所有具有管理权限且可继续授权的子机构
	 * @param authUserId 机构管理用户ID
	 * @param parentOrgId 父机构ID
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getCanManageAndAuthChildOrgs(Long authUserId, Long parentOrgId) {
		return getCanManageOrAuthChildOrgs(authUserId, parentOrgId, true);
	}
	
	/**
	 * 根据权限查询指定父机构下的所有具有管理权限或可继续授权的子机构
	 * @param authUserId
	 * @param parentOrgId
	 * @param needLoadAuthOrgs 是否启用获取可继续授权机构约束
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getCanManageOrAuthChildOrgs(Long authUserId, Long parentOrgId, boolean needLoadAuthOrgs) {
		if (authUserId != null && parentOrgId != null) {

			//系统管理员
			if (omUserService.isSystemAdmin(authUserId)) {
				List<OmOrgForm> childOrgs = this.getChildOrgs(parentOrgId);
				OrgUtils.setOrgCheckedProp(childOrgs, true);
				return childOrgs;
			}

			//机构管理员
			else {
				
				//获取指定用户所有可授权管理或可继续授权的机构列表
				List<OmOrgForm> canManageOrAuthOrgs = null;
				
				if(needLoadAuthOrgs)
					canManageOrAuthOrgs = this.getCanManageAndAuthOrgs(authUserId);
				else
					canManageOrAuthOrgs = this.getCanManageOrgs(authUserId);				
				
				
				//获取指定父机构的子机构列表，子机构列表可分为不可授权管理和可授权管理两种
				List<OmOrgForm> childOrgs = this.getChildOrgsInAllRelatedOrgIds(parentOrgId, OrgUtils.getAllRelatedOrgIdsBySeq(canManageOrAuthOrgs));
				OrgUtils.setTopOrgCheckedProp(childOrgs, canManageOrAuthOrgs);
				return childOrgs;
			}
		}
		
		return null;
	}
	
	/**
	 * 判断该用户是否为机构管理员
	 * @param userId 用户ID
	 * @param orgIds 机构ID或ID数组
	 * @return 是否为机构管理员.如果有权限返回true，没有权限则返回false
	 */
	@Transactional(readOnly = true)
	public boolean isOrgAdmin(Long userId, Long... orgIds) {
		return omOrgDao.isOrgAdmin(userId, orgIds);
	}

	/**
	 * 注意：如果是修改机构则直接判断用户是否对该机构有管理权限， 如果是新增机构则判断用户是否对该机构的父机构有管理权限。
	 * 如果用户为超级管理员，则直接调用普通save接口即可。
	 * @param userId 管理用户主键
	 * @param form 要新增或修改的机构form对象
	 */
	public ResultForm<Object> save(Long userId, OmOrgForm form) {
		ResultForm<Object> result = new ResultForm<Object>(false);
		if (userId != null && form != null) {

			// 超级管理员
			if (this.omUserService.isSystemAdmin(userId)) {
				this.save(form);
				result.setSuccess(true);
			}

			// 普通用户
			else {
				// 修改
				if (form.getOrgId() != null) {
					if (this.isOrgAdmin(userId, form.getOrgId())) {
						this.save(form);
						result.setSuccess(true);
					} else
						MsgUtils.addNoOrgPrivilegeError(result);

				}
				// 新增
				else {
					if (this.isOrgAdmin(userId, form.getParentOrgId())) {
						this.save(form);
						result.setSuccess(true);
					} else
						MsgUtils.addNoParentOrgPrivilegeError(result);
				}
			}
		}
		return result;
	}

	/**
	 * 注意：如果是修改机构则直接判断用户是否对该机构有管理权限， 如果是新增机构则判断用户是否对该机构的父机构有管理权限。
	 * 如果用户为超级管理员，则直接调用普通saveOrgCascade接口即可。
	 * @param userId 管理用户主键
	 * @param forms 要新增或修改的机构form对象
	 */
	public ResultForm<Object> saveOrgCascade(Long userId, OmOrgForm form) {
		ResultForm<Object> result = new ResultForm<Object>(false);
		
		// 超级管理员
		if(this.omUserService.isSystemAdmin(userId)) {
			this.save(form);
			result.setSuccess(true);
		}

		// 普通用户
		else{
			// 修改
			if(form.getOrgId() != null) {
				if(this.isOrgAdmin(userId, form.getOrgId())) {
					this.save(form);
					result.setSuccess(true);
				} else
					MsgUtils.addNoOrgPrivilegeError(result);
			}
			// 新增
			else{
				if(this.isOrgAdmin(userId, form.getParentOrgId())) {
					this.save(form);
					result.setSuccess(true);
				} else
					MsgUtils.addNoParentOrgPrivilegeError(result);
			}
		}
		return result;
	}

	/**
	 * 根据查询面板的查询条件查询机构，条件为OmOrgForm的5个属性:
	 * orgCode,orgName,orgType,orgGrade,status
	 * @param form 条件查询对象
	 * @Param page 分页对象
	 * @return 符合条件的分页查询结果
	 */
	@Transactional(readOnly = true)
	public Page<OmOrgForm> searchOrg(Long curUserId, OmOrgForm form, Page<OmOrgForm> page, Map<String, List<SysCodeForm>> sysCodeBuffer) {
		if (form != null && page != null) {
			// 建立分页对象
			Page<OmOrg> pg = PageUtils.newPageInstance(page);

			StringBuffer hql = new StringBuffer("from OmOrg ps where 1=1");
			List values = new ArrayList();

			//权限条件
			hql.append(this.buildPrivHql(curUserId));
			
			//查询条件
			if (form.getOrgCode() != null
					&& form.getOrgCode().trim().length() > 0) {
				hql.append(" and ps.orgCode like ?");
				values.add("%" + form.getOrgCode() + "%");
			}
			if (form.getOrgName() != null
					&& form.getOrgName().trim().length() > 0) {
				hql.append(" and ps.orgName like ?");
				values.add("%" + form.getOrgName() + "%");
			}
			if (form.getOrgType() != null
					&& form.getOrgType().trim().length() > 0) {
				hql.append(" and ps.orgType = ?");
				values.add(form.getOrgType());
			}
			if (form.getOrgGrade() != null
					&& form.getOrgGrade().trim().length() > 0) {
				hql.append(" and ps.orgGrade = ?");
				values.add(form.getOrgGrade());
			}
			if (form.getStatus() != null
					&& form.getStatus().trim().length() > 0) {
				hql.append(" and ps.status = ?");
				values.add(form.getStatus());
			}

			// 排序
			pg.setOrderBy(OmOrgForm.convertToValuePropertyName(page.getOrderBy()));
			hql.append(HqlUtils.buildOrderBy(pg, "ps"));

			pg = omOrgDao.findPage(pg, hql.toString(), values);

			// 转换为Form对象列表并赋值到原分页对象中
			List<OmOrgForm> list = OmOrgConverter.convertToFormList(pg.getResult(), 
					sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_TYPE, sysCodeBuffer), 
					sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_GRADE, sysCodeBuffer), 
					sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_STATUS, sysCodeBuffer));
			
			//设置机构的完整路径
			setOrgPath(list);
			
			PageUtils.copy(pg, list, page);
		}
		return page;
	}
	
	/**
	 * 构造Hql语句，用于查找用户具有管理权限的工作组
	 * @param userId 用户id
	 * @return
	 */
	@Transactional(readOnly = true)
	private String buildSearchGroupHql(Long userId, Long orgId){
		if(userId != null){
			//查询用户可以管理的工作组
			Long[] groupIds = this.getCanManaGroupIds(userId,orgId);
				
			if(groupIds != null && groupIds.length > 0){
				return " and " + HqlUtils.buildOrCondition("ps", "groupId", groupIds);
			}
		}
		return " and 1!=1";
	}
	
	/**
	 * 根据用户权限，多条件查询查询某个机构下的工作组列表，
	 * 条件为OmGroupForm的4个属性:工作组名称、工作组类型、隶属机构的名称、工作组所在层次
	 * @param adminUserId 用户登录时的id
	 * @param orgId 机构id
	 * @param form 条件查询对象 
	 * @Param page 分页对象
	 * @return 符合条件的分页查询结果
	 * */
	@Transactional(readOnly = true)
	public Page<OmGroupForm> searchGroupsInOrgByPriv(Long adminUserId, Long orgId, OmGroupForm form,Page<OmGroupForm> page, Map<String, List<SysCodeForm>> sysCodeBuffer){
		if (form != null && page != null) {
			// 建立分页对象
			Page pg = PageUtils.newPageInstance(page);

			StringBuffer hql = new StringBuffer("select ps from OmGroup ps, OmOrg oo where 1= 1 and ps.orgId=oo.orgId");
			//构造查询hql语句
			hql.append(this.buildSearchGroupHql(adminUserId, orgId));
			
			List values = new ArrayList();
			if(form != null){
				if(form.getGroupName() != null && form.getGroupName().trim().length() > 0){
					hql.append(" and ps.groupName like ?");
					values.add("%" + form.getGroupName() + "%");
				}
				if(form.getGroupType() != null && form.getGroupType().trim().length() > 0){
					hql.append(" and ps.groupType = ?");
					values.add(form.getGroupType());
				}
				if(form.getOrgName() != null && form.getOrgName().trim().length() > 0){
					hql.append(" and oo.orgName like ?");
					values.add("%" + form.getOrgName() + "%");
				}
				if(form.getGroupLevel() != null){
					hql.append(" and ps.groupLevel = ?");
					values.add(form.getGroupLevel());
				}
			}
			hql.append(HqlUtils.buildOrderBy(page, "ps"));
			pg = omOrgDao.findPage(pg, hql.toString(), values);
			
			List<OmGroupForm> list = OmGroupConverter.convertToFormList(
					pg.getResult(), 
					this.getAll(), 
					omGroupService.getAllGroups(),
					sysCodeService.getItems(OrgConstant.SYS_CODE_GROUP_TYPE),
					sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_STATUS)
			);
			PageUtils.copy(pg, list, page);
			return page;
		}
		return null;
	}
	
	/**
	 * 获取全部机构
	 * @return 机构form对象列表
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getAll(){
		List<OmOrg> entities = omOrgDao.getAll();
		return OmOrgConverter.convertToFormList(entities);
	}

	/**
	 * 分页查询全部机构form 对象
	 * @param page 分页对象
	 * @return 分页处理后的全部机构form 对象
	 */
	@Transactional(readOnly = true)
	public Page<OmOrgForm> getAll(Page<OmOrgForm> page) {
		if (page != null) {
			// 建立分页对象
			Page<OmOrg> pg = PageUtils.newPageInstance(page);

			// 分页查询
			pg = omOrgDao.getAll(pg);

			// 转换为Form对象列表并赋值到原分页对象中
			List<OmOrgForm> list = OmOrgConverter.convertToFormList(pg
					.getResult());
			PageUtils.copy(pg, list, page);
		}
		return page;
	}

	

	/**
	 * 根据机构id数组获取一批机构（包括机构的子机构）下的所有的用户
	 * @param orgIds 机构id数组
	 * @return 用户id数组
	 */
	@Transactional(readOnly = true)
	public Long[] getAllUserIdsByOrgIds(Long[] orgIds) {
		List<Long> orgIdList = new ArrayList<Long>();
		if (orgIds != null && orgIds.length > 0) {
			for (Long orgId : orgIds) {
				List<Long> childOrgIdList = omOrgDao.getAllChildOrgIds(orgId);
				if (childOrgIdList != null && childOrgIdList.size() > 0)
					orgIdList.addAll(childOrgIdList);
				orgIdList.add(orgId);
			}
		}

		if (orgIdList != null && orgIdList.size() > 0) {
			return omUserOrgDao.getUserIdsByOrgIds(CollectionUtils.toLongArray(orgIdList));
		}
		return null;
	}

	/**
	 * 获取指定机构是否是管理用户的授权机构的父机构
	 */
	@Transactional(readOnly = true)
	public Set<Long> getPrivParentOrgIds(Long adminUserId) {
		Set<Long> set = null;
		if (adminUserId != null) {
			// 获取授权机构id
			List<Long> list = omOrgAdminDao.getCanManageOrgIds(adminUserId);

			// 解析授权机构id
			set = new HashSet<Long>();
			if (list != null && list.size() > 0) {
				for (int i = 0; i < list.size(); i++) {
					set.addAll(this.getParentorgIds(list.get(i)));
				}
			}

		}
		return set;
	}

	/**
	 * 获取授权机构下的所有的子机构，返回结果包括授权机构本身
	 * 即获取指定用户所有可授权管理的机构ID列表
	 * @param authUserId 授权用户ID
	 * @param return 获取授权机构下的所有的子机构
	 */
	@Transactional(readOnly = true)
	public List<Long> getCanManageOrgIds(Long authUserId) {
		return omOrgDao.getCanManageOrgIds(authUserId);
	}
	
	/**
	 * 获取机构下的所有的子机构，返回结果包括本身
	 * @param orgIds 机构ID列表
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<Long> getSelfAndChildOrgIds(List<Long> orgIds){
		return omOrgDao.getSelfAndChildOrgIds(orgIds);
	}
	
	/**
	 * 获取授权机构下的所有的子机构，返回结果包括授权机构本身
	 * 即获取指定用户所有可授权管理的机构ID列表
	 * @param authUserId 授权用户ID
	 * @param return 获取授权机构下的所有的子机构
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getCanManageOrgs(Long authUserId) {
		if (authUserId != null) {
			if(omUserService.isSystemAdmin(authUserId)){
				return this.getAll();
			}
			else{
				// 获取授权机构id
				List<Long> authedOrgIds = omOrgAdminDao.getCanManageOrgIds(authUserId);
				// 通过机构序列查询所有授权机构的子机构
				return OmOrgConverter.convertToForm(this.getSelfAndChildOrgs(authedOrgIds));
			}
		}else
			return null;
	}
	
	/**
	 * 获取授权机构下的所有的子机构，返回结果包括授权机构本身
	 * 即获取指定用户所有可授权管理的机构ID列表
	 * @param authUserId 授权用户ID
	 * @param return 获取授权机构下的所有的子机构
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getCanManageAndAuthOrgs(Long authUserId) {
		if (authUserId != null) {
			if(omUserService.isSystemAdmin(authUserId)){
				return this.getAll();
			}
			else{
				// 获取授权机构id
				List<Long> authedOrgIds = omOrgAdminDao.getCanManageAndAuthOrgIds(authUserId);
				// 通过机构序列查询所有授权机构的子机构
				return OmOrgConverter.convertToForm(this.getSelfAndChildOrgs(authedOrgIds));
			}
		}else
			return null;
	}
	
	/**
	 * 获取机构下的所有的子机构，返回结果包括本身
	 * @param orgIds
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrg> getSelfAndChildOrgs(List<Long> orgIds){
		if (orgIds != null && orgIds.size() > 0) {
			String hql = "from OmOrg ps where 1!=1 ";
			for (Long orgId : orgIds){
				hql += " or ps.orgSeq like '%." + orgId + ".%'";
			}
			return omOrgDao.find(hql);
		}else
			return null;
	}
	
	/**
	 * 解析机构的orgSeq，得到所有的父机构
	 */
	@Transactional(readOnly = true)
	private List<Long> getParentorgIds(Long orgId) {
		List<Long> list = null;
		if (orgId != null) {
			list = new ArrayList<Long>();
			String seq = this.get(orgId).getOrgSeq();
			String strs[] = seq.split("\\.");

			if (strs.length > 2) {
				// 去掉最后一个，因为是自己本身；去掉strs[0]，因为是空字符串
				for (int i = 1; i < strs.length - 1; i++) {
					list.add(Long.parseLong(strs[i]));
				}
			}
		}
		return list;
	}

	/**
	 * 主键为adminUserId的管理员给主键为userId的用户授机构管理权限
	 * @param authUserId 授权用户ID
	 * @param authedUserId 被授权用户ID
	 * @param authNewManagedOrgIds 要给用户授权的机构主键列表
	 */
	public void authManagedOrgs(Long authUserId, Long authedUserId, String auth, Long... authNewManagedOrgIds) {
		if (authUserId != null && authedUserId != null) {
			//系统管理员或机构管理员
			if(canManageOrg(authUserId, authNewManagedOrgIds)){
				omOrgAdminDao.authNewOrgs(authedUserId, auth, authNewManagedOrgIds);
			}
		}
	}
	
	/**
	 * 构造权限过滤条件
	 * @param curUserId
	 * @return
	 */
	@Transactional(readOnly = true)
	public String buildPrivHql(Long curUserId){
		if(curUserId != null){
			//系统管理员
			if(omUserService.isSystemAdmin(curUserId))
				return "";
			
			//机构管理员
			else{
				List<Long> list = this.getCanManageOrgIds(curUserId);
				if(list != null && list.size() > 0)
					return " and " + HqlUtils.buildOrCondition("ps", "orgId", CollectionUtils.toLongArray(list));
			}
		}
		
		return " and 1!=1";
	}
	
	/**
	 * 获取机构下直属工作组
	 * @param orgId
	 * @return
	 */
	@Transactional(readOnly = true)
	public Long[] getDirectGroupIds(Long orgId){
		if(orgId != null){
			return omGroupService.getDirectGroupIdsByOrg(orgId);
		}
		return null;
	}
	
	/**
	 * 获取机构下的工作组
	 * @param orgId 机构Id
	 * @return 工作组列表
	 */
	@Transactional(readOnly = true)
	public List<OmGroupForm> getDirectGroups(Long orgId){
		if(orgId != null){
			return omGroupService.getDirectGroupsByOrg(orgId);
		}
		return null;
	}
	
	/**
	 * 分页获取机构下的工作组
	 * @param orgId 机构id
	 * @param page 分页参数
	 * @return 分页工作组对象
	 */
	@Transactional(readOnly = true)
	public Page<OmGroupForm> getDirectGroups(Long orgId, Page<OmGroupForm> page){
		return null;
	}
	
	/**
	 * 获取某个机构下的所有工作组包括直属工作组和间接工作组
	 * @param userId 用户id
	 * @param orgId 机构id
	 * @param page 分页参数
	 * @return 工作组form分页对象
	 */
	@Transactional(readOnly = true)
	public Page<OmGroupForm> getAllGroupsInOrg(Long userId, Long orgId, Page<OmGroupForm> page){
		if(userId != null && orgId != null){
			Page pg = PageUtils.newPageInstance(page);
			
			Long[] directGroupIds = this.getDirectGroupIds(orgId);
			List groupList = new ArrayList();
			if(directGroupIds != null && directGroupIds.length > 0){
				CollectionUtils.addArrayToList(groupList, directGroupIds);
			}
			String hql = "select ps from OmGroup ps where " + HqlUtils.buildOrCondition("ps", "groupId", CollectionUtils.toLongArray(groupList)) ;
			
			pg = omOrgDao.findPage(pg, hql);
			
			List<OmGroupForm> list = OmGroupConverter.convertToFormList(pg.getResult());
			PageUtils.copy(pg, list, page);
			return page;
			
		}
		return null;
	}
	
	/**
	 * 获取工作组的直属父机构
	 * @param groupIds
	 * @return
	 */
	@Transactional(readOnly = true)
	public Long[] getDirectParentOrgIds(Long...groupIds){
		if(groupIds != null && groupIds.length > 0){
			return omGroupService.getDirectParentOrgIds(groupIds);
		}
		return null;
	}
	
	/**
	 * 判断机构parentOrgId是否为childOrgId的父机构
	 * @param parentOrgId
	 * @param childOrgId
	 * @return
	 */
	@Transactional(readOnly = true)
	private boolean isPaternity(Long parentOrgId, Long childOrgId){
		int len1 = 0;
		if(parentOrgId != null){
			OmOrgForm form1 = omOrgDao.getForm(parentOrgId);
			len1 = form1.getOrgSeq().split("\\.").length;
		}
		OmOrgForm form2 = omOrgDao.getForm(childOrgId);
		int len2 = form2.getOrgSeq().split("\\.").length;
		return (len2 == (len1+1)?true:false);
	}
	
	
	/**
	 * 主键为orgId的机构是否是主键为groupId的工作组的祖先
	 * @param orgId 机构主键
	 * @param groupId 工作组主键
	 * @return 如果主键为orgId的机构是主键为groupId的工作组的祖先，返回true.否则返回false
	 */
	public boolean isAncestor(OmOrgForm orgForm, OmGroupForm groupForm){
		if(orgForm != null && groupForm != null){
			
			OmOrgForm directParentOrgForm = null;
			if(groupForm != null){
				directParentOrgForm = this.get(groupForm.getOrgId());
			}
			
			if(directParentOrgForm != null){
				return directParentOrgForm.getOrgSeq().indexOf(orgForm.getOrgSeq()) >= 0;
			}
		}
		return false;
	}
	
	
	/**
	 * 获取主键为userId的用户具有管理权限、
	 * 且主键为orgId的机构下具有工作组（可以是直属的、也可以非直属）的直属孩子机构
	 * @userId 用户id
	 * @param orgId 机构id
	 * @return 机构form对象
	 */
	public List<OmOrgForm> getNextLevelOrgOwendGroup(Long userId, Long orgId){
		List<OmOrgForm> result = null;
		Set<OmOrgForm> orgFormSet = null;
		if(orgId != null){
			//获取当前机构下用户具有管理权限的所有子机构
			List<OmOrgForm> childOrgList = this.getCanManageChildOrgs(userId, orgId);
			
			if(childOrgList != null && childOrgList.size() > 0){
				orgFormSet = new HashSet<OmOrgForm>();
				
				//获取所有的工作组
				List<OmGroupForm> allGroups = omGroupService.getAllGroups();
				for(OmGroupForm groupForm:allGroups){
					
					for(OmOrgForm childOrgForm:childOrgList){
						if(isAncestor(childOrgForm, groupForm) && isPaternity(orgId, childOrgForm.getOrgId())){
								orgFormSet.add(childOrgForm);
						}
					}
				}
			}
			
		}
		
		if(orgFormSet != null && orgFormSet.size() > 0){
			result = new ArrayList<OmOrgForm>();
			for(Iterator iter = orgFormSet.iterator(); iter.hasNext();){
				result.add((OmOrgForm)iter.next());
			}
		}
		return result;
	}
	
	/**
	 * 获取具有工作组的机构列表
	 * @return 机构列表
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getOrgsOwnedGroup(){
		String hql = "select distinct oo from OmGroup ps, OmOrg oo where ps.orgId = oo.orgId";
		List<OmOrg> list = omOrgDao.find(hql);
		return OmOrgConverter.convertToForm(list);
	}
	
	/**
	 * 获取指定工作组的直接父机构
	 * @param groupIds 工作组id数组
	 * @return 机构列表
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getDirectParentOrgs(Long...groupIds){
		if(groupIds != null && groupIds.length > 0){
			String hql = "select distinct oo from OmGroup ps, OmOrg oo where ps.orgId = oo.orgId and " + HqlUtils.buildOrCondition("ps", "groupId", groupIds);
			List<OmOrg> list = omOrgDao.find(hql);
			return OmOrgConverter.convertToForm(list);
		}
		return null;
	}

	/**
	 * 获取某个用户从父机构开始可管理的机构，包括父机构本身
	 * @param userId 用户id
	 * @param parentOrgId 父机构 
	 * @return 机构列表
	 */
	@Transactional(readOnly = true)
	private List<OmOrgForm> getCanManaOrgsInOrg(Long userId, Long parentOrgId){
		List<OmOrgForm> orgList = new ArrayList();
		
		//如果是从根结点开始
		if(parentOrgId == -1L){
			orgList = this.getCanManageOrgs(userId);
		}
		//否则是从某个机构开始
		else{
			orgList.add(this.get(parentOrgId));
			List childOrgList = this.getCanManageChildOrgs(userId, parentOrgId);
			if(childOrgList != null && childOrgList.size() > 0)
				orgList.addAll(childOrgList);
		}
		return orgList;
	}
	/**
	 * 获取用户可以管理的工作组
	 * @param parentOrgId
	 * @param userId 用户id
	 * @return
	 */
	@Transactional(readOnly = true)
	public Long[] getCanManaGroupIds(Long userId, Long parentOrgId){
		//获取用户可以管理的机构列表
		List<OmOrgForm> orgList = this.getCanManaOrgsInOrg(userId, parentOrgId);
			
		List<Long> result = null;
		if(orgList != null && orgList.size() > 0){
			result = new ArrayList<Long>();
			for(OmOrgForm form:orgList){
				//获取机构下的直属工作组
				Long[] directGroupIds = this.getDirectGroupIds(form.getOrgId());
				CollectionUtils.addArrayToList(result, directGroupIds);
			}
		}
		return CollectionUtils.toLongArray(result);
	}
	
	/**
	 * 获取拥有工作组的顶级机构form列表
	 * @param userId 用户id
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<OmOrgForm> getTopOrgsOwnedGroup(Long userId){
		if(userId != null){
			if(omUserService.isSystemAdmin(userId)){
				//获取拥有工作组的机构id数组
				List<OmOrgForm> orgList = this.getOrgsOwnedGroup();
				List<OmOrgForm> topOrgList = this.get(OrgUtils.getTopOrgIds(orgList));
				OrgUtils.setOrgCheckedProp(topOrgList, true);
				return topOrgList;
			}
			else{
				//获取用户可以管理的工作组id数组
				Long[] groupIds = this.getCanManaGroupIds(userId, -1L);
				//获取这些工作组的直属父机构
				List<OmOrgForm> directOrgList = this.getDirectParentOrgs(groupIds);
				//获取机构的顶层机构
				List<OmOrgForm> topOrgList = this.get(OrgUtils.getTopOrgIds(directOrgList));
				List<OmOrgForm> canManaOrgList = this.getCanManageOrgs(userId);
				OrgUtils.setTopOrgCheckedProp(topOrgList, canManaOrgList);
				return topOrgList;
			}
		}
		return null;
	}
	
	/**
	 * 设置机构的完整路径
	 * @param list
	 */
	private void setOrgPath(List<OmOrgForm> list){
		if(list != null && list.size() > 0){
			for(OmOrgForm form : list){
				form.setOrgPath(getOrgPath(form));
			}
		}
	}
	
	/**
	 * 根据机构ID获取机构的完整路径，如“/test/test1/test11”
	 * @param form
	 * @return
	 */
	private String getOrgPath(OmOrgForm form){
		String result = "";
		
		if(form != null){
			String[] orgIds = OrgUtils.splitSeqToArray(form.getOrgSeq());
			
			if(orgIds != null && orgIds.length > 0){
				for(String id : orgIds){
					result += OrgConstant.STRING_SEPARATOR_MODULEPATH + omOrgDao.get(Long.valueOf(id)).getOrgName();
				}
			}
		}
		
		return result;
	}
	
	@Transactional(readOnly = true)
	public List<OmOrgForm> getOrgsByCodeList(List<String> orgCodeList){
		if(orgCodeList != null && orgCodeList.size() > 0){
			String hql = "from OmOrg ps where " + HqlUtils.buildOrCondition("ps", "orgCode", CollectionUtils.toStringArray(orgCodeList));
			List<OmOrg> list = this.omOrgDao.find(hql);
			return OmOrgConverter.convertToFormList(list);
		}else
			return null;
	}
	
	/**
	 * 根据机构code获取机构form对象
	 * @param orgCode
	 * @return
	 */
	@Transactional(readOnly = true)
	public OmOrgForm getOrgByCode(String orgCode){
		OmOrgForm form = null;
		if(orgCode != null && orgCode.trim().length()>0){
			String hql = "from OmOrg ps where ps.orgCode='"+orgCode.trim()+"'";
			List<OmOrg> list = this.omOrgDao.find(hql);
			if(list != null && list.size()>0){
				OmOrg entity = list.get(0);
				form = OmOrgConverter.convertToForm(entity);
			}
		}
		return form;
	}
	
	public boolean isOrgLikeKeyword(Long orgId,String keyword){
		
		if(orgId != null && keyword != null && keyword.trim().length()>0){
			//先判断该机构是否匹配
			OmOrgForm orgForm = this.get(orgId);
			if(isLikeKeyword(orgForm,keyword))
				return true;
			
			//不匹配则,看其子机构是否匹配
			else{
				List<OmOrgForm> orgList = this.getAllChildOrgs(orgId); 
				if(isLikeKeyword(orgList,keyword))
					return true;
				
				//不匹配
				else{
					
				/*	//其子机构的岗位是否匹配
					if(this.omPositionService.isOrgListPosLikeKeyword(orgList,keyword))
						return true;
					
					//机构的用户是否匹配
					else{*/
						if(orgList == null)
							orgList = new ArrayList<OmOrgForm>();
						orgList.add(orgForm);
						List<OmUserForm> userList = this.omUserService.getUserByOrgListAndKeyword(orgList, keyword);
						if(userList != null && userList.size()>0)
							return true;
				//	}
				}
			}
		}
		return false;
	}
	
	public boolean isLikeKeyword(List<OmOrgForm>list,String keyword){
		boolean bool =  false;
		if(list != null &&list.size()>0 && keyword != null && keyword.trim().length()>0){
			for(OmOrgForm form :list){
				if(isLikeKeyword(form,keyword))
					return true;
			}
		}
		return bool;
	}
	
	public boolean isLikeKeyword(OmOrgForm form,String keyword){
		boolean bool =  false;
		if(form != null && keyword != null && keyword.trim().length()>0){
			if(form.getOrgName().length()>=keyword.length()){
				String subStr = form.getOrgName().substring(0, keyword.length());
				if(subStr.equals(keyword))
					return true;
			}
		}
		return bool;
	}
	
	//机构表中是否有匹配的记录
	public boolean hasOrgLikeKeyword(List<OmOrgForm> list,String keyword){
		if(keyword != null && keyword.trim().length()>0 && list != null && list.size()>0){
			if(list != null && list.size()>0){
				for(OmOrgForm form:list){
					if(isOrgLikeKeyword(form.getOrgId(),keyword))
						return true;
				}
			}
		}
		return false;
	}

	@Override
	public OmOrg getOrgByUserId(Long userId) {
		String sql="select org from OmOrg org,OmUserOrg uorg where uorg.orgId=org.orgId" +
				" and uorg.userId="+userId;
		List<OmOrg> list=this.omOrgDao.find(sql);
		if(list.size()>0)
			return list.get(0);
		return null;
	}
}
